package com.styletransfer.service;

import com.aliyuncs.utils.StringUtils;
import com.styletransfer.exception.BusinessException;
import com.styletransfer.mapper.*;
import com.styletransfer.model.*;
import com.styletransfer.service.OssService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 风格服务类
 *
 * 这个类负责处理与风格相关的业务逻辑，包括风格的创建、更新、查询等。
 */
@Service
public class StyleService {

    @Autowired
    private StyleMapper styleMapper;

    @Autowired
    private TagMapper tagMapper;

    @Autowired
    private WorkMapper workMapper;

    @Autowired
    private FavoriteMapper favoriteMapper;

    @Autowired
    private StyleCategoryMapper styleCategoryMapper;

    @Autowired
    private OssService ossService;

    @Autowired
    private UserMapper userMapper;

    /**
     * 创建风格
     *
     * @param style 风格对象
     * @param tagIds 标签ID列表
     * @return API响应
     */
    @Transactional
    public ApiResponse<Style> createStyle(Style style, List<Long> tagIds) {
        // 获取当前登录用户
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        String username = authentication.getName();

        // 设置创建者ID
        style.setCreatorId(getCurrentUserId());

        // 检查必要的字段
        if (style.getCoverImage() == null || style.getCoverImage().isEmpty()) {
            throw new BusinessException("封面图片不能为空");
        }

        if (style.getPreviewImage() == null || style.getPreviewImage().isEmpty()) {
            throw new BusinessException("预览图片不能为空");
        }

        // 设置默认值
        style.setUseCount(0);
        style.setLikeCount(0);
        style.setFavoriteCount(0);
        style.setCreateTime(new Date());
        style.setUpdateTime(new Date());
        style.setStatus(1); // 1:正常, 0:禁用

        // 如果是管理员创建的风格，则设置为官方风格
        if (isAdmin()) {
            style.setType(1); // 1:官方, 2:用户
        } else {
            style.setType(2); // 1:官方, 2:用户
        }

        // 插入风格
        styleMapper.insert(style);

        // 添加标签关联
        if (tagIds != null && !tagIds.isEmpty()) {
            for (Long tagId : tagIds) {
                tagMapper.addStyleTag(style.getId(), tagId);
            }
        }

        return ApiResponse.success(style);
    }

    /**
     * 更新风格
     *
     * @param style 风格对象
     * @param tagIds 标签ID列表
     * @return API响应
     */
    @Transactional
    public ApiResponse<Style> updateStyle(Style style,List<Long> tagIds) {
        // 检查风格是否存在
        Style existingStyle = styleMapper.findById(style.getId());
        if (existingStyle == null) {
            throw new BusinessException("风格不存在");
        }

        // 检查是否有权限修改
        if (!isAdmin() && !existingStyle.getCreatorId().equals(getCurrentUserId())) {
            throw new BusinessException("没有权限修改此风格");
        }

        // 设置不可修改的字段
        style.setCreatorId(existingStyle.getCreatorId());
        style.setType(existingStyle.getType());
        style.setUseCount(existingStyle.getUseCount());
        style.setLikeCount(existingStyle.getLikeCount());
        style.setFavoriteCount(existingStyle.getFavoriteCount());
        style.setCreateTime(existingStyle.getCreateTime());
        style.setStatus(existingStyle.getStatus());
        style.setUpdateTime(new Date());

        // 更新风格
        styleMapper.update(style);

        // 更新标签关联
        if (tagIds != null) {
            // 删除所有标签关联
            tagMapper.removeAllStyleTags(style.getId());

            // 添加新的标签关联
            for (Long tagId : tagIds) {
                tagMapper.addStyleTag(style.getId(), tagId);
            }
        }

        return ApiResponse.success(style);
    }

    /**
     * 删除风格
     *
     * @param id 风格ID
     * @return API响应
     */
    @Transactional
    public ApiResponse<Void> deleteStyle(Long id) {
        // 检查风格是否存在
        Style style = styleMapper.findById(id);
        if (style == null) {
            throw new BusinessException("风格不存在");
        }

        // 检查是否有权限删除
        if (!isAdmin() && !style.getCreatorId().equals(getCurrentUserId())) {
            throw new BusinessException("没有权限删除此风格");
        }

        // 删除图片
        if (style.getCoverImage() != null && !style.getCoverImage().isEmpty()) {
            ossService.deleteFile(style.getCoverImage());
        }
        if (style.getPreviewImage() != null && !style.getPreviewImage().isEmpty()) {
            ossService.deleteFile(style.getPreviewImage());
        }

        // 删除标签关联
        tagMapper.removeAllStyleTags(id);

        // 更新风格状态为已删除
        styleMapper.updateStatus(id, 0);

        return ApiResponse.success();
    }

    /**
     * 根据ID获取风格
     *
     * @param id 风格ID
     * @return API响应
     */
    public ApiResponse<Style> findById(Long id) {
        if (id == null) {
            return ApiResponse.error("风格ID不能为空");
        }

        Style style = styleMapper.findById(id);
        if (style == null) {
            return ApiResponse.error("风格不存在");
        }

        return ApiResponse.success(style);
    }

    /**
     * 根据ID数组批量获取风格列表
     *
     * @param ids 风格ID数组
     * @return API响应
     */
    public ApiResponse<List<Style>> findByIds(List<Long> ids) {
        if (ids == null || ids.isEmpty()) {
            return ApiResponse.error("风格ID列表不能为空");
        }

        List<Style> styles = styleMapper.findByIds(ids);
        return ApiResponse.success(styles);
    }

    /**
     * 查询风格的标签
     *
     * @param styleId 风格ID
     * @return API响应
     */
    public ApiResponse<List<Tag>> findTags(Long styleId) {
        // 检查风格是否存在
        Style style = styleMapper.findById(styleId);
        if (style == null) {
            throw new BusinessException("风格不存在");
        }

        // 查询标签
        List<Tag> tags = tagMapper.findByStyle(styleId);

        return ApiResponse.success(tags);
    }

    /**
     * 查询所有风格
     *
     * @return API响应
     */
    public ApiResponse<List<Style>> findAll() {
        List<Style> styles = styleMapper.findAll();
        return ApiResponse.success(styles);
    }

    /**
     * 查询官方风格
     *
     * @return API响应
     */
    public ApiResponse<List<Style>> findOfficial() {
        List<Style> styles = styleMapper.findOfficial();
        return ApiResponse.success(styles);
    }

    /**
     * 查询用户创建的风格
     *
     * @param creatorId 创建者ID
     * @return API响应
     */
    public ApiResponse<List<Style>> findByCreator(Long creatorId) {
        List<Style> styles = styleMapper.findByCreator(creatorId);
        return ApiResponse.success(styles);
    }

    /**
     * 查询热门风格
     *
     * @param limit 限制数
     * @return API响应
     */
    public ApiResponse<List<Style>> findHot(Integer limit) {
        List<Style> styles = styleMapper.findHot(limit);
        return ApiResponse.success(styles);
    }

    /**
     * 根据分类查询风格
     *
     * @param category 分类
     * @return API响应
     */
    public ApiResponse<List<Style>> findByCategory(Integer category) {
        List<Style> styles = styleMapper.findByCategory(Long.valueOf(category));
        return ApiResponse.success(styles);
    }

    /**
     * 搜索风格
     *
     * @param keyword 关键词
     * @return API响应
     */
    public ApiResponse<List<Style>> search(String keyword) {
        List<Style> styles = styleMapper.search(keyword);
        return ApiResponse.success(styles);
    }

    /**
     * 分页查询风格
     *
     * @param pageRequest 分页请求
     * @return 分页响应
     */
    public PageResponse<Style> findByPage(PageRequest pageRequest) {
        // 计算偏移量
        Integer offset = (pageRequest.getPageNum() - 1) * pageRequest.getPageSize();

        // 查询数据
        List<Style> styles = styleMapper.findByPage(offset, pageRequest.getPageSize());
        Long total = styleMapper.count();

        // 构建分页响应
        return new PageResponse<>(styles, total, pageRequest.getPageNum(), pageRequest.getPageSize());
    }

    /**
     * 分页查询风格（支持多条件）
     *
     * @param pageRequest 分页请求
     * @param keyword 关键词
     * @param tagId 标签ID
     * @param categoryId 分类ID
     * @param userId 用户ID
     * @param orderBy 排序字段
     * @param orderType 排序类型
     * @return 分页响应
     */
    public PageResponse<Style> findByPage(
            PageRequest pageRequest,
            String keyword,
            Long tagId,
            Long categoryId,
            Long userId,
            String orderBy,
            String orderType) {
        // 计算偏移量
        Integer offset = (pageRequest.getPageNum() - 1) * pageRequest.getPageSize();

        // 查询数据
        List<Style> styles = styleMapper.findByPageWithConditions(
                offset,
                pageRequest.getPageSize(),
                keyword,
                tagId,
                categoryId,
                userId,
                orderBy,
                orderType);

        Long total = styleMapper.countWithConditions(keyword, tagId, categoryId, userId);

        // 构建分页响应
        return new PageResponse<>(styles, total, pageRequest.getPageNum(), pageRequest.getPageSize());
    }

    /**
     * 增加风格使用次数
     *
     * @param id 风格ID
     * @return API响应
     */
    public ApiResponse<Void> incrementUseCount(Long id) {
        // 检查风格是否存在
        Style style = styleMapper.findById(id);
        if (style == null) {
            throw new BusinessException("风格不存在");
        }

        // 增加使用次数
        styleMapper.incrementUseCount(id);

        return ApiResponse.success();
    }

    /**
     * 获取当前用户ID
     *
     * @return 用户ID
     */
    private Long getCurrentUserId() {
        try {
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            Object principal = authentication.getPrincipal();

            // 从自定义UserDetails中获取用户ID
            if (principal instanceof com.styletransfer.security.CustomUserDetailsService.CustomUserDetails) {
                return ((com.styletransfer.security.CustomUserDetailsService.CustomUserDetails) principal).getUserId();
            }

            // 尝试从请求属性中获取用户ID
            javax.servlet.http.HttpServletRequest request =
                    ((org.springframework.web.context.request.ServletRequestAttributes)
                            org.springframework.web.context.request.RequestContextHolder.getRequestAttributes()).getRequest();
            Object userId = request.getAttribute("userId");
            if (userId != null) {
                return (Long) userId;
            }

            throw new RuntimeException("无法获取用户ID");
        } catch (Exception e) {
            throw new RuntimeException("获取用户ID失败: " + e.getMessage());
        }
    }

    /**
     * 检查当前用户是否为管理员
     *
     * @return 是否为管理员
     */
    private boolean isAdmin() {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        return authentication.getAuthorities().stream()
                .anyMatch(authority -> authority.getAuthority().equals("ROLE_ADMIN"));
    }

    /**
     * 查询最新风格
     *
     * @param limit 限制数量
     * @return API响应
     */
    public ApiResponse<List<Style>> findLatest(Integer limit) {
        List<Style> styles = styleMapper.findLatest(limit);
        return ApiResponse.success(styles);
    }

    /**
     * 根据用户ID查询风格
     *
     * @param userId 用户ID
     * @return API响应
     */
    public ApiResponse<List<Style>> findByUser(Long userId) {
        List<Style> styles = styleMapper.findByCreator(userId);
        return ApiResponse.success(styles);
    }

    /**
     * 查询当前用户的风格
     *
     * @return API响应
     */
    public ApiResponse<List<Style>> findByCurrentUser() {
        Long userId = getCurrentUserId();
        return findByUser(userId);
    }

    /**
     * 根据标签查询风格
     *
     * @param tagId 标签ID
     * @return API响应
     */
    public ApiResponse<List<Style>> findByTag(Long tagId) {
        List<Style> styles = styleMapper.findByTag(tagId);
        return ApiResponse.success(styles);
    }

    /**
     * 查询公开风格（用户创建的正常状态风格）
     *
     * @return API响应
     */
    public ApiResponse<List<Style>> findPublic() {
        List<Style> styles = styleMapper.findPublic();
        return ApiResponse.success(styles);
    }

    /**
     * 查询相关风格
     *
     * @param styleId 风格ID
     * @param limit 限制数量
     * @return API响应
     */
    public ApiResponse<List<Style>> findRelatedStyles(Long styleId, Integer limit) {
        // 检查风格是否存在
        Style style = styleMapper.findById(styleId);
        if (style == null) {
            throw new BusinessException("风格不存在");
        }

        // 查询相关风格
        // 这里可以根据实际需求实现相关风格的查询逻辑
        // 例如：根据标签相似度、风格类型、创建者等因素查询相关风格
        // 这里简单实现为：查询同类型的其他风格
        List<Style> relatedStyles = styleMapper.findRelated(styleId, style.getType(), limit);

        return ApiResponse.success(relatedStyles);
    }

    /**
     * 查询风格相关作品
     *
     * @param styleId 风格ID
     * @param pageRequest 分页请求
     * @return API响应
     */
    public ApiResponse<PageResponse<Work>> findStyleWorks(Long styleId, PageRequest pageRequest) {
        // 检查风格是否存在
        Style style = styleMapper.findById(styleId);
        if (style == null) {
            throw new BusinessException("风格不存在");
        }

        // 计算偏移量
        Integer offset = (pageRequest.getPageNum() - 1) * pageRequest.getPageSize();

        // 查询风格相关作品
        List<Work> works = workMapper.findByStylePage(styleId, offset, pageRequest.getPageSize());

        // 设置用户信息和风格标签
        for (Work work : works) {
            if (work.getUserId() != null) {
                work.setUser(userMapper.findById(work.getUserId()));
            }

            // 设置风格标签
            if (work.getStyleId() != null && !work.getStyleId().isEmpty()) {
                List<String> tags = new ArrayList<>();
                String[] styleIdArray = work.getStyleId().split(",");
                for (String styleIdStr : styleIdArray) {
                    try {
                        Long styleId2 = Long.valueOf(styleIdStr.trim());
                        Style style1 = styleMapper.findById(styleId2);
                        if (style1 != null) {
                            tags.add(style1.getName());
                        }
                    } catch (NumberFormatException e) {
                        // 忽略无效的风格ID
                    }
                }
                work.setTags(tags);
            }
        }

        Long total = workMapper.countByStyle(styleId);

        // 构建分页响应
        PageResponse<Work> pageResponse = new PageResponse<>(works, total, pageRequest.getPageNum(), pageRequest.getPageSize());
        return ApiResponse.success(pageResponse);
    }

    /**
     * 收藏/取消收藏风格
     *
     * @param styleId 风格ID
     * @param favorite 是否收藏
     * @return API响应
     */
    public ApiResponse<Void> toggleFavorite(Long styleId, Boolean favorite) {
        // 检查风格是否存在
        Style style = styleMapper.findById(styleId);
        if (style == null) {
            throw new BusinessException("风格不存在");
        }

        // 获取当前用户ID
        Long userId = getCurrentUserId();

        // 查询是否已收藏
        Favorite existingFavorite = favoriteMapper.findByUserAndTarget(userId, styleId, 1); // 1表示风格类型

        // 如果favorite为null，则自动切换状态
        if (favorite == null) {
            favorite = (existingFavorite == null);
        }

        if (favorite && existingFavorite == null) {
            // 添加收藏
            Favorite newFavorite = new Favorite();
            newFavorite.setUserId(userId);
            newFavorite.setTargetId(styleId);
            newFavorite.setType(1); // 1表示风格类型
            newFavorite.setCreateTime(new Date());
            favoriteMapper.insert(newFavorite);

            // 增加风格收藏数
            styleMapper.incrementFavoriteCount(styleId);
        } else if (!favorite && existingFavorite != null) {
            // 取消收藏
            favoriteMapper.delete(existingFavorite.getId());

            // 减少风格收藏数
            styleMapper.decrementFavoriteCount(styleId);
        }

        return ApiResponse.success();
    }

    /**
     * 检查风格是否已收藏
     *
     * @param styleId 风格ID
     * @return API响应
     */
    public ApiResponse<Boolean> isFavorite(Long styleId) {
        // 检查风格是否存在
        Style style = styleMapper.findById(styleId);
        if (style == null) {
            throw new BusinessException("风格不存在");
        }

        // 获取当前用户ID
        Long userId = getCurrentUserId();

        // 查询是否已收藏
        Favorite favorite = favoriteMapper.findByUserAndTarget(userId, styleId, 1); // 1表示风格类型

        return ApiResponse.success(favorite != null);
    }

    /**
     * 获取风格分类列表
     *
     * @return API响应
     */
    public ApiResponse<List<StyleCategory>> getStyleCategories() {
        List<StyleCategory> categories = styleCategoryMapper.findAll();
        return ApiResponse.success(categories);
    }

    /**
     * 获取所有风格分类（包括禁用的）
     *
     * @return API响应
     */
    public ApiResponse<List<StyleCategory>> getAllStyleCategories() {
        List<StyleCategory> categories = styleCategoryMapper.findAllWithDisabled();
        return ApiResponse.success(categories);
    }

    /**
     * 根据ID获取风格分类
     *
     * @param id 分类ID
     * @return API响应
     */
    public ApiResponse<StyleCategory> getStyleCategoryById(Long id) {
        if (id == null) {
            return ApiResponse.error("分类ID不能为空");
        }

        StyleCategory category = styleCategoryMapper.findById(id);
        if (category == null) {
            return ApiResponse.error("分类不存在");
        }

        return ApiResponse.success(category);
    }

    /**
     * 创建风格分类
     *
     * @param category 风格分类
     * @return API响应
     */
    public ApiResponse<StyleCategory> createStyleCategory(StyleCategory category) {
        // 参数校验
        if (category == null) {
            return ApiResponse.error("分类信息不能为空");
        }

        if (StringUtils.isEmpty(category.getName())) {
            return ApiResponse.error("分类名称不能为空");
        }

        // 设置默认值
        if (category.getSort() == null) {
            category.setSort(0);
        }

        if (category.getStatus() == null) {
            category.setStatus(1); // 默认启用
        }

        // 创建分类
        int rows = styleCategoryMapper.insert(category);
        if (rows <= 0) {
            return ApiResponse.error("创建分类失败");
        }

        return ApiResponse.success(category);
    }

    /**
     * 更新风格分类
     *
     * @param category 风格分类
     * @return API响应
     */
    public ApiResponse<StyleCategory> updateStyleCategory(StyleCategory category) {
        // 参数校验
        if (category == null || category.getId() == null) {
            return ApiResponse.error("分类信息不完整");
        }

        if (StringUtils.isEmpty(category.getName())) {
            return ApiResponse.error("分类名称不能为空");
        }

        // 检查分类是否存在
        StyleCategory existingCategory = styleCategoryMapper.findById(category.getId());
        if (existingCategory == null) {
            return ApiResponse.error("分类不存在");
        }

        // 设置默认值
        if (category.getSort() == null) {
            category.setSort(existingCategory.getSort());
        }

        if (category.getStatus() == null) {
            category.setStatus(existingCategory.getStatus());
        }

        // 更新分类
        int rows = styleCategoryMapper.update(category);
        if (rows <= 0) {
            return ApiResponse.error("更新分类失败");
        }

        return ApiResponse.success(category);
    }

    /**
     * 删除风格分类
     *
     * @param id 分类ID
     * @return API响应
     */
    public ApiResponse<Void> deleteStyleCategory(Long id) {
        // 参数校验
        if (id == null) {
            return ApiResponse.error("分类ID不能为空");
        }

        // 检查分类是否存在
        StyleCategory category = styleCategoryMapper.findById(id);
        if (category == null) {
            return ApiResponse.error("分类不存在");
        }

        // 检查分类是否被使用
        List<Style> styles = styleMapper.findByCategory(id);
        if (styles != null && !styles.isEmpty()) {
            return ApiResponse.error("该分类下存在风格，无法删除");
        }

        // 删除分类
        int rows = styleCategoryMapper.delete(id);
        if (rows <= 0) {
            return ApiResponse.error("删除分类失败");
        }

        return ApiResponse.success();
    }

    /**
     * 更新风格分类状态
     *
     * @param id 分类ID
     * @param status 状态
     * @return API响应
     */
    public ApiResponse<Void> updateStyleCategoryStatus(Long id, Integer status) {
        // 参数校验
        if (id == null) {
            return ApiResponse.error("分类ID不能为空");
        }

        if (status == null || (status != 0 && status != 1)) {
            return ApiResponse.error("状态值无效");
        }

        // 检查分类是否存在
        StyleCategory category = styleCategoryMapper.findById(id);
        if (category == null) {
            return ApiResponse.error("分类不存在");
        }

        // 更新状态
        int rows = styleCategoryMapper.updateStatus(id, status);
        if (rows <= 0) {
            return ApiResponse.error("更新状态失败");
        }

        return ApiResponse.success();
    }
}
